/*
 * the one.c
 *
 * Created: 2019-05-09 08:38:33
 * Author : da7550bo-s
 */ 

#include <avr/io.h>


// ***************************************************************************************************/

#include <avr\io.h>
#include "delay.h"
#include "i2c.h"

//------------------------------------------------------------------------------------*/
void I2C_Init()
{
    TWSR=0x00; //set presca1er bits to zero
    TWBR=0x46; //SCL frequency is 50K for 16Mhz
    TWCR=0x04; //enab1e TWI module
}

// ***************************************************************************************************/
void I2C_Start()
{
    TWCR = ((1<<TWINT) | (1<<TWSTA) | (1<<TWEN));
    while (!(TWCR & (1<<TWINT)));
}
 /***************************************************************************************************/

void I2C_Stop(void)
{
    TWCR = ((1<< TWINT) | (1<<TWEN) | (1<<TWSTO));
    DELAY_us(100) ;
}
/******************************************************/
void I2C_Write(uint8_t v_i2cData_u8)
{
    TWDR = v_i2cData_u8 ;
    TWCR = ((1<< TWINT) | (1<<TWEN));
    while (!(TWCR & (1 <<TWINT)));
}
/***************************************************************************************************/
uint8_t I2C_Read(uint8_t v_ackOption_u8)
{
    TWCR = ((1<< TWINT) | (1<<TWEN) | (v_ackOption_u8<<TWEA));
    while ( !(TWCR & (1 <<TWINT)));
    return TWDR;
}
/***************************************************************************************************/

#include "rtc.h"
#include "i2c.h"
/***************************************************************************************************/
void RTC_Init(void)
{
    I2C_Init();                             // Initialize the I2c module.
    I2C_Start();                            // Start I2C communication

    I2C_Write(C_Ds1307WriteMode_U8);        // Connect to DS1307 by sending its ID on I2c Bus
    I2C_Write(C_Ds1307ControlRegAddress_U8);// Select the Ds1307 ControlRegister to configure Ds1307

    I2C_Write(0x00);                        // Write 0x00 to Control register to disable SQW-Out

    I2C_Stop();                             // Stop I2C communication after initializing DS1307
}
/***************************************************************************************************/
void RTC_SetDateTime(rtc_t *rtc)
{
    I2C_Start();                          // Start I2C communication

    I2C_Write(C_Ds1307WriteMode_U8);      // connect to DS1307 by sending its ID on I2c Bus
    I2C_Write(C_Ds1307SecondRegAddress_U8); // Request sec RAM address at 00H

    I2C_Write(rtc->sec);                    // Write sec from RAM address 00H
    I2C_Write(rtc->min);                    // Write min from RAM address 01H
    I2C_Write(rtc->hour);                    // Write hour from RAM address 02H
    I2C_Write(rtc->weekDay);                // Write weekDay on RAM address 03H
    I2C_Write(rtc->date);                    // Write date on RAM address 04H
    I2C_Write(rtc->month);                    // Write month on RAM address 05H
    I2C_Write(rtc->year);                    // Write year on RAM address 06h

    I2C_Stop();                              // Stop I2C communication after Setting the Date
}

/******************************************************************************************************/
void RTC_SetDate(rtc_t *rtc)
{
	I2C_Start();                          // Start I2C communication

	I2C_Write(C_Ds1307WriteMode_U8);      // connect to DS1307 by sending its ID on I2c Bus
	I2C_Write(C_Ds1307SecondRegAddress_U8); // Request sec RAM address at 00H

	I2C_Write(rtc->date);                    // Write date on RAM address 04H
	I2C_Write(rtc->month);                    // Write month on RAM address 05H
	I2C_Write(rtc->year);                    // Write year on RAM address 06h

	I2C_Stop();                              // Stop I2C communication after Setting the Date
}


void RTC_SetTime(rtc_t *rtc)
{
	I2C_Start();                          // Start I2C communication

	I2C_Write(C_Ds1307WriteMode_U8);      // connect to DS1307 by sending its ID on I2c Bus
	I2C_Write(C_Ds1307SecondRegAddress_U8); // Request sec RAM address at 00H

	I2C_Write(rtc->sec);                    // Write sec from RAM address 00H
	I2C_Write(rtc->min);                    // Write min from RAM address 01H
	I2C_Write(rtc->hour);                    // Write hour from RAM address 02H

	I2C_Stop();                              // Stop I2C communication after Setting the Date
}
/***************************************************************************************************/
void RTC_GetDateTime(rtc_t *rtc)
{
    I2C_Start();                            // Start I2C communication

    I2C_Write(C_Ds1307WriteMode_U8);        // connect to DS1307 by sending its ID on I2c Bus
    I2C_Write(C_Ds1307SecondRegAddress_U8); // Request Sec RAM address at 00H

    I2C_Stop();                                // Stop I2C communication after selecting Sec Register

    I2C_Start();                            // Start I2C communication
    I2C_Write(C_Ds1307ReadMode_U8);            // connect to DS1307(Read mode) by sending its ID

    rtc->sec = I2C_Read(1);                // read second and return Positive ACK
    rtc->min = I2C_Read(1);                 // read minute and return Positive ACK
    rtc->hour= I2C_Read(1);               // read hour and return Negative/No ACK
    rtc->weekDay = I2C_Read(1);           // read weekDay and return Positive ACK
    rtc->date= I2C_Read(1);              // read Date and return Positive ACK
    rtc->month=I2C_Read(1);            // read Month and return Positive ACK
    rtc->year =I2C_Read(0);             // read Year and return Negative/No ACK

    I2C_Stop();                              // Stop I2C communication after reading the Date
}

/***************************************************************************************************/

#include <util\delay.h>
#include"delay.h"

void DELAY_us(uint16_t us_count) 
{
    while (us_count != 0) 
    {
        _delay_us(1);
		us_count--;
    }
}


void DELAY_ms(uint16_t ms_count) 
{
    while (ms_count != 0) 
    {
        _delay_us(1000); //DELAY_us is called to generate 1ms delay
        ms_count--;
    }
}

#if (ENABLE_DELAY_sec == 1)

void DELAY_sec(uint16_t sec_count) 
{
    while (sec_count != 0) {
        DELAY_ms(1000); //DELAY_ms is called to generate 1sec delay
        sec_count--;
    }
}
#endif

//***************************************************************************************************************************************************************************************************

#ifndef F_CPU
#define F_CPU 16000000UL // 16 MHz clock speed
#endif

#define D0 eS_PORTA0
#define D1 eS_PORTA1
#define D2 eS_PORTA2
#define D3 eS_PORTA3
#define D4 eS_PORTA4
#define D5 eS_PORTA5
#define D6 eS_PORTA6
#define D7 eS_PORTA7
#define RS eS_PORTD6
#define EN eS_PORTD5

#include <avr/io.h>
#include <util/delay.h>
#include "lcd.h"


uint8_t button_read(uint8_t num)
{
	num = num - 1;
	// Returns 1 if button number 'num' is pressed, otherwise 0
	return ((PIND & (1 << num)) >> num);
}

/********************************************************************/
uint16_t dutyCycle = 0;
uint16_t period = 1000;


int main(void)

{ 
	
	rtc_t rtc;
	 RTC_Init();   // initialiserar RTC.
	 
	 
	 DDRA = 0xFF;
	 DDRD = 0b01100000;
	 PIND = 0b00000111;
	 
	 Lcd8_Init();
	 
	 
/* Buffert tid*/
	char sec [100];
	char min [100];
	char hour[100];
	char hour2[100];
	char min2 [100];
	char sec2[100];
	
/* Buffert datum*/
    char day [100];
	char day2 [100];
	char month[100];
	char month2[100];
	char year [100];
	char year2[100];
	
	int hourDig;
	int minDig;
	int secDig;
	
	int dayDig;
	int monthDig;
	int yearDig;	
	
	
	/*Buffert alarm*/
	
	char printhour1 [100];
	char printhour2 [100];
	char printmin1[100];
	char printmin2[100];
		
	char sethour1 [100];
	char sethour2 [100];
	char setmin1[100];
	char setmin2[100];
	char setday1 [100];
	char setday2 [100];
	char setmonth1 [100];
	char setmonth2 [100];
	
	char setyear1 [100];
	char setyear2 [100];
	
	/* Alarm ints*/
	
	int alarmhour=500;
	int alarmmin=500;
	
	int alarmhour2=500;
	int alarmmin2=500;
	int alarmhourdiv=0;
	int alarmmindiv=0;
	
	
	int hourcomp=500;
	int mincomp=500;
	
	
		char hourset=0b00000000;
		char minset=0b00000000;
		char secset=0b00000000;
		
		char hourset2=0b00000000;
		char minset2=0b00000000;
		char secset2=0b00000000;
		
		char hoursetsave=0b00000000;
		char minsetsave=0b00000000;
		
		char dayset=0b00000000;
		char monthset=0b00000000;
		char yearset=0b00000000;
		
		char dayset2=0b00000000;
		char monthset2=0b00000000;
		char yearset2=0b00000000;
		
		char daysetsave=0b00000000;
		char monthsetsave=0b00000000;
		char yearsetsave=0b00000000;
		
		int hourcopy;
		int mincopy;
		int seccopy;
		
    /* Replace with your application code */
    while (1) 
    {
		if ((button_read(3)==1))			// Funktion för att ställa in tiden, den ändrade tiden skickas till RTC.
		{
			_delay_ms(1000);
			
			Lcd8_Set_Cursor(1,0);
			Lcd8_Write_String("Set time    ");
			Lcd8_Set_Cursor(2,5);
			Lcd8_Write_String("                ");
			
			while ((button_read(1)!=1)){
				
				if (button_read(3)==1)
				{
					hourset= hourset + 0b00000001;
					
					_delay_ms(100);	
				}
				
				if (button_read(2)==1)
				{
					minset = minset + 0b00000001;
					
					_delay_ms(100);
				}
				
				 while (hourset > 9){
					
					hourset=hourset-0b00001010;
					hourset2++;
				}
				if ((hourset==4) && (hourset2==2))
				{hourset2=0;
					hourset=0;
					hoursetsave=0;	
				}
				while (minset > 9){
					minset=minset-0b00001010;
					minset2++;
				}
				
				if ((minset==9) && (minset2==5))
				{minset2=0;
					minset=0;
					minsetsave=0;
				}
				
				itoa(hourset2, sethour1, 10 );
				itoa(hourset, sethour2, 10 );
				itoa(minset2, setmin1, 10 );
				itoa(minset, setmin2, 10 );
				
				
				Lcd8_Set_Cursor(2,0);
				Lcd8_Write_String(sethour1);
				Lcd8_Set_Cursor(2,1);
				Lcd8_Write_String(sethour2);
				
				Lcd8_Set_Cursor(2,2);
				Lcd8_Write_String(":");
				
				Lcd8_Set_Cursor(2,3);
				Lcd8_Write_String(setmin1);
				Lcd8_Set_Cursor(2,4);
				Lcd8_Write_String(setmin2);
				
				 hoursetsave = ((hourset2<<4) + hourset);
				 minsetsave = ((minset2	<<4) + minset);
				
				rtc.hour = hoursetsave;
				rtc.min =  minsetsave;
				rtc.sec =  0b00000000;
				
				 RTC_SetTime(&rtc);  
				_delay_ms(100);
			}
		}
		
		if ((button_read(2)==1))  // funktion för att ställa datum, det ändrade datumet skickas till RTC.
		{
			dayset=0;
			monthset=0;
			yearset=19;
			
			dayset2=0;
			monthset2=0;
			yearset2=0;
			
			
			_delay_ms(1000);
			
			Lcd8_Set_Cursor(1,0);
			Lcd8_Write_String("Set date    ");
			Lcd8_Set_Cursor(2,5);
			Lcd8_Write_String("                ");
			
			while ((button_read(1)!=1)){
				
				if (button_read(3)==1)
				{
					dayset++;	
					_delay_ms(100);
				}
				
				if (button_read(2)==1)
				{
					monthset++;	
					_delay_ms(100);
				}
				
				while (dayset > 9){
					
					dayset=dayset-10;
					dayset2++;
					
				}
				if ((dayset==2) && (dayset2==3))
				{dayset2=0;
					dayset=0;
					
					
				}
				while (monthset > 9){
					monthset=monthset-10;
					monthset2++;
				}
				
				if ((monthset==3) && (monthset2==1))
				{monthset2=0;
					monthset=0;
					yearset++;
					
				}
				while(yearset >9){
					yearset = yearset-10;
					yearset2++;
				}
				itoa(dayset2, setday1, 10 );
				itoa(dayset, setday2, 10 );
				itoa(monthset2, setmonth1, 10 );
				itoa(monthset, setmonth2, 10 );
				itoa(yearset2,setyear1,10);
				itoa(yearset,setyear2,10);
				
				
				Lcd8_Set_Cursor(2,0);
				Lcd8_Write_String(setday1);
				Lcd8_Set_Cursor(2,1);
				Lcd8_Write_String(setday2);
				
				Lcd8_Set_Cursor(2,2);
				Lcd8_Write_String("/");
				
				Lcd8_Set_Cursor(2,3);
				Lcd8_Write_String(setmonth1);
				Lcd8_Set_Cursor(2,4);
				Lcd8_Write_String(setmonth2);
				
				Lcd8_Set_Cursor(2,5);
				Lcd8_Write_String("/");
				
				Lcd8_Set_Cursor(2,6);
				Lcd8_Write_String(setyear1);
				Lcd8_Set_Cursor(2,7);
				Lcd8_Write_String(setyear2);
				
				daysetsave = ((dayset2 <<4)+dayset);      // Left-shiftar variablerna dayset2,monthset2 och yeastset2 för RTC ska tolka insignalen på rätt sätt. 
				monthsetsave = ((monthset2 <<4)+monthset);  //0b0000 1111 de första ettorna är ental och resterande tolkars som tiotal.
				yearsetsave = ((yearset2 <<4)+yearset);
				
                  RTC_GetDateTime(&rtc);
				  hourcopy=rtc.hour;
				  mincopy=rtc.min;
				  seccopy=rtc.sec;
				
				
				
				rtc.date = daysetsave;
				rtc.month = monthsetsave;
				rtc.year = yearsetsave;
				rtc.hour=hourcopy;
				rtc.min=mincopy;
				rtc.sec=seccopy;
				
				RTC_SetDateTime(&rtc);
				
				
				_delay_ms(100);
			}
		}
			
		hourDig = 0;
		minDig = 0;
		secDig = 0;
		dayDig = 0;
		monthDig = 0;
		yearDig = 0;

		RTC_GetDateTime(&rtc);   // hämtar tid och datum från RTC.
		
		
		while (rtc.hour > 10){ 			//Värdet från RTC måste delas upp i ental och tiotal för att sedan kunna visas på displayen. 
			rtc.hour=rtc.hour-0x10;
			hourDig++;
		}
		while (rtc.min > 10){
			rtc.min=rtc.min-0x10;
			minDig++;
		}
		while (rtc.sec > 10){
			rtc.sec=rtc.sec-0x10;
			secDig++;
		}
		
		
		while (rtc.date > 10){
			rtc.date=rtc.date-0x10;
			dayDig++;
		}
		while (rtc.month > 10){
			rtc.month=rtc.month-0x10;
			monthDig++;
		}
		while (rtc.year > 10){
			rtc.year=rtc.year-0x10;
			yearDig++;
		}
		
		// Omvandla int till string tid
		
		
		itoa(hourDig, hour, 16);
		itoa(rtc.hour, hour2, 16);
		itoa(minDig, min, 16);
		itoa(rtc.min, min2, 16);
		itoa(secDig, sec, 16);
		itoa(rtc.sec, sec2, 16);
		
		
		// Omvandla int till string datum
		itoa(dayDig, day, 16);
		itoa(rtc.date, day2, 16);
		itoa(monthDig, month, 16);
		itoa(rtc.month, month2, 16);
		itoa(yearDig, year, 16);
		itoa(rtc.year, year2, 16);
		
		// Printa tiden på första raden.
		Lcd8_Set_Cursor(1,0);
		Lcd8_Write_String(hour);
		Lcd8_Set_Cursor(1,1);
		Lcd8_Write_String(hour2);
		Lcd8_Set_Cursor(1,2);
		Lcd8_Write_String(":");
		Lcd8_Set_Cursor(1,3);
		Lcd8_Write_String(min);
		Lcd8_Set_Cursor(1,4);
		Lcd8_Write_String(min2);
		Lcd8_Set_Cursor(1,5);
		Lcd8_Write_String(":");
		Lcd8_Set_Cursor(1,6);
		Lcd8_Write_String(sec);
		Lcd8_Set_Cursor(1,7);
		Lcd8_Write_String(sec2);
		Lcd8_Set_Cursor(1,8);
		Lcd8_Write_String(" ");
		
		
			//* Printa datum på andra raden
		Lcd8_Set_Cursor(2,0);
		Lcd8_Write_String(day);
		Lcd8_Set_Cursor(2,1);
		Lcd8_Write_String(day2);
		Lcd8_Set_Cursor(2,2);
		Lcd8_Write_String("/");
		Lcd8_Set_Cursor(2,3);
		Lcd8_Write_String(month);
		Lcd8_Set_Cursor(2,4);
		Lcd8_Write_String(month2);
		Lcd8_Set_Cursor(2,5);
		Lcd8_Write_String("/");
		Lcd8_Set_Cursor(2,6);
		Lcd8_Write_String(year);
		Lcd8_Set_Cursor(2,7);
		Lcd8_Write_String(year2);
		
		
		if ((button_read(2)==1)&&(button_read(3)==1))  // nollställa larmet.
		{
			_delay_ms(100);
			mincomp=500;
			hourcomp=500;
			
			alarmhour2=500;
		    alarmhour=500;
			alarmmin2=500;
			alarmmin=500;
			Lcd8_Set_Cursor(2,15);
			Lcd8_Write_String(" ");
			Lcd8_Set_Cursor(1,15);
			Lcd8_Write_String(" ");
			
		}
		
		
		//RTC_GetDateTime(&rtc);
		
		if ((alarmhour2==hourDig) && (alarmhour==rtc.hour) && (alarmmin2==minDig) && (alarmmin==rtc.min)){ //Jämförelse funktion för larmet.
			
			DDRB = (1 << PORTB6); //Sätter port B6 till output
			
			TCCR3A = (1 << COM3A1) | (1 << WGM31);// | (1 << WGM01);  // Reg TCCR0A BIT 7 = Clear OC0A on Compare Match, BIT 1 är  phase correct, 9-bit.
			
			OCR3A = dutyCycle; //Sätter värdet som jämförs med.
			ICR3 = period;
			TCCR3B = (1 << CS31) | (1 << CS30); // 64 prescaler
			
			if(dutyCycle<1000){
				dutyCycle++;
				
				OCR3A=dutyCycle;     
				
				_delay_ms(10);
				if(dutyCycle == 1000){
					dutyCycle = 1000;
					OCR3A = dutyCycle;
				}
			}
			
			if (button_read(1)==1)     // Funktion för att stänga av larm.
			{
				_delay_ms(100);
				dutyCycle=0;
				OCR3A = dutyCycle;
				alarmhour2=500;
				alarmhour=500;
				alarmmin2=500;
				alarmmin=500;
				mincomp=500;
				hourcomp=500;
				Lcd8_Set_Cursor(2,15);
				Lcd8_Write_String(" ");
				Lcd8_Set_Cursor(1,15);
				Lcd8_Write_String(" ");
				
				
			}
		}									// Funktionen för att ställa larm.
		
		if(button_read(1) == 1) {
			_delay_ms(1000);
			
			alarmhour2=0;
			alarmhour=0;
			alarmmin2=0;
			alarmmin=0;
			
			while (button_read(1) != 1)
			{
				
				Lcd8_Set_Cursor(1,0);
				Lcd8_Write_String("Set alarm     ");
				Lcd8_Set_Cursor(2,5);
				Lcd8_Write_String("                ");
				
				
				if (button_read(3)==1) {
					alarmhour++;
					
					hourcomp=alarmhour;
					_delay_ms(100);
					
				}
				
				if (button_read(2) == 1) {
					alarmmin++;
					mincomp=alarmmin;
					_delay_ms(100);
				}
				
				while (alarmhour > 9){
					
					alarmhour=alarmhour-10;
					alarmhour2++;
					
				}
				if ((alarmhour==4) && (alarmhour2==2))
				{alarmhour2=0;
					alarmhour=0;
					hourcomp=0;
				}
				while (alarmmin > 9){
					alarmmin=alarmmin-10;
					alarmmin2++;
				}
				
				if ((alarmmin==9) && (alarmmin2==5))
				{alarmmin2=0;
					alarmmin=0;
					hourcomp=0;
				}
				
				itoa(alarmhour2, printhour1, 10 );
				itoa(alarmhour, printhour2, 10 );
				itoa(alarmmin2, printmin1, 10 );
				itoa(alarmmin, printmin2, 10 );
				
				
				Lcd8_Set_Cursor(2,0);
				Lcd8_Write_String(printhour1);
				Lcd8_Set_Cursor(2,1);
				Lcd8_Write_String(printhour2);
				
				Lcd8_Set_Cursor(2,2);
				Lcd8_Write_String(":");
				
				Lcd8_Set_Cursor(2,3);
				Lcd8_Write_String(printmin1);
				Lcd8_Set_Cursor(2,4);
				Lcd8_Write_String(printmin2);
			
				if ((hourcomp!=500)||(mincomp!=500)){
					Lcd8_Set_Cursor(1,15);
					Lcd8_Write_String("*");
				}
				

				
			}
			
		
			
			
		}
		
		
    } 
 }